import UDPManager from '../../utils/udpManager';
import MDNSManager from '../../utils/mdnsManager';
import CommandManager from '../../utils/commandManager';
import ElectricalDataCommand from '../../utils/commands/electricalDataCommand';
import SwitchStateCommand from '../../utils/commands/switchStateCommand';
import QuerySwitchStateCommand from '../../utils/commands/querySwitchStateCommand';
import QueryEnergyCountCommand from '../../utils/commands/queryEnergyCountCommand';
import QueryEnergyRecordCommand from '../../utils/commands/queryEnergyRecordCommand';
import QueryEnergyDateCommand from '../../utils/commands/queryEnergyDateCommand';
import sharedUdpManager from '../../utils/sharedUdpManager';

Page({
  // 页面的初始数据
  data: {
    isConnected: false,   // 设备连接状态
    isPowerOn: false,     // 设备开关状态
    currentPower: '--',   // 当前功率值
    voltage: '--',        // 电压值
    current: '--',        // 电流值
    todayEnergy: '--',    // 今日用电量，KWh
    activeTab: 'week',      // 默认显示周视图
    scanning: false,      // 扫描状态
    deviceList: [],       // 设备列表
    tcpSocket: null,      // TCP Socket 实例
    tcpConnected: false,  // TCP 连接状态
    isLoading: false,    // 是否正在加载
    hasMore: true,        // 是否还有更多数据
    pageSize: 10,         // 每页显示的设备数量
    currentPage: 1,        // 当前页码
    showDeviceList: false, // 控制设备列表显示
    pullDownDistance: 0,   // 下拉距离
    connecting: false,    // 是否正在连接中
    currentDevice: null,   // 保存当前连接的设备信息
    debugTimer: null,      // 用于存储调试信息定时器
    udpManager: null,      // 添加 UDP 管理器实例
    mdnsManager: null,
    lastToggleTime: 0,     // 添加上次切换时间记录
    energyRecords: [],     // 用于存储用电记录
    recordCount: 0,        // 记录总数
    currentRecordIndex: 0, // 当前查询的记录索引
    chartData: {
      week: [],   // 周统计数据
      month: []   // 月统计数据
    },
    todayEnergyTimer: null,  // 添加定时器变量
    chartContext: null,
    chartWidth: 0,
    chartHeight: 0,
    chartInitialized: false,  // 添加标记表示图表是否已初始化
    animation: {
      timer: null,
      startData: [],
      targetData: [],
      isAnimating: false,
      duration: 300  // 动画持续时间（毫秒）
    },
    touchInfo: {
      touching: false,
      index: -1,
      totalEnergy: 0,    // 添加总耗电量字段
      currentEnergy: 0,  // 添加当前选中的耗电量
      currentDate: ''    // 添加当前选中的日期
    },
    selectedDate: {
      year: new Date().getFullYear(),
      month: new Date().getMonth() + 1,
      day: new Date().getDate()
    },
    displayDate: '',  // 显示的日期文本
    showDatePicker: false,
    weeks: ['日', '一', '二', '三', '四', '五', '六'],
    days: [],      // 当月日期数组
    prevMonthDays: [], // 上月显示的日期
    nextMonthDays: [], // 下月显示的日期
    tempDate: {    // 临时日期，用于选择器
      year: 2023,
      month: 1,
      day: 1
    },
    displayEnergy: '--',  // 显示的耗电量
    lastTouchedEnergy: null,  // 最后触摸的日期的耗电量
    deviceInfo: null,  // 添加设备信息字段
  },

  // 页面加载时执行
  onLoad() {
    // 创建实例
    const udpManager = new UDPManager();
    const mdnsManager = new MDNSManager();
    
    this.setData({ 
      udpManager,
      mdnsManager
    });

    // 保存到全局数据
    getApp().globalData.udpManager = udpManager;

    // 设置 mDNS 回调
    mdnsManager.onDeviceFound((device) => {
      // 检查设备是否已存在
      const exists = this.data.deviceList.some(d => d.hostname === device.hostname);
      if (!exists) {
        this.setData({
          deviceList: [...this.data.deviceList, device]
        });
      }
    });

    mdnsManager.onDeviceLost((serviceName) => {
      this.setData({
        deviceList: this.data.deviceList.filter(
          device => device.hostname !== serviceName
        )
      });
    });

    mdnsManager.onError((err) => {
      console.error('[扫描] 错误:', err);
      wx.showToast({
        title: '设备扫描失败',
        icon: 'none'
      });
      this.setData({ scanning: false });
    });

    // 绑定 UDP 消息处理器
    this.bindUDPMessageHandler();

    udpManager.onError((err) => {
      this.handleDisconnect();
    });

    // 开启下拉刷新
    wx.startPullDownRefresh();
    
    // 初始化设备状态数据
    this.initDeviceStatus();

    // 在 onLoad 中初始化显示日期
    this.updateDisplayDate();
  },

  // 添加绑定 UDP 消息处理器的方法
  bindUDPMessageHandler() {
    // 先清除可能存在的旧处理器
    if (this.data.udpManager) {
      this.data.udpManager.clearMessageHandlers();
      
      // 绑定新的处理器
      this.data.udpManager.onMessage(this.handleReceivedData.bind(this));
    }
  },

  // 页面显示时执行
  onShow() {
    // 页面显示时刷新设备状态
    this.refreshDeviceStatus();
    
    // 重新绑定消息处理器
    this.bindUDPMessageHandler();
  },

  // 初始化设备状态
  initDeviceStatus() {
    console.log('[设备] 等待连接...');
  },

  // 修改切换开关状态方法
  togglePower() {
    const { udpManager } = this.data;
    if (!udpManager || !udpManager.isConnected) {
      wx.showToast({
        title: '设备未连接',
        icon: 'none'
      });
      return;
    }

    // 检查切换间隔
    const now = Date.now();
    const minInterval = 500; // 最小间隔 500ms
    if (now - this.data.lastToggleTime < minInterval) {
      console.log('[开关] 切换过于频繁，请稍后再试');
      wx.showToast({
        title: '操作过于频繁',
        icon: 'none'
      });
      return;
    }

    // 更新最后切换时间
    this.setData({
      lastToggleTime: now
    });

    // 获取当前状态的反值
    const newPowerState = !this.data.isPowerOn;
    
    // 创建并发送开关命令
    const frame = CommandManager.createCommand('SWITCH_STATE', newPowerState);
    if (!frame) {
      console.error('[开关] 创建命令失败');
      return;
    }

    // 显示加载提示
    wx.showLoading({
      title: newPowerState ? '正在开启' : '正在关闭',
      mask: true  // 添加遮罩防止重复操作
    });

    // 设置2秒超时
    const loadingTimeout = setTimeout(() => {
      this.setData({ loadingTimeout: null });
      wx.hideLoading();
      wx.showToast({
        title: '操作超时',
        icon: 'none'
      });
    }, 2000);

    // 保存超时定时器到data中，以便在收到响应时清除
    this.setData({ loadingTimeout });

    // 发送命令
    udpManager.send(frame)
      .catch(err => {
        console.error('[开关] 控制失败:', err);
        if (this.data.loadingTimeout) {
          clearTimeout(this.data.loadingTimeout);
          this.setData({ loadingTimeout: null });
        }
        wx.hideLoading();
        wx.showToast({
          title: '操作失败',
          icon: 'error'
        });
      })
      .finally(() => {
        // 确保可以进行下拉刷新
        wx.stopPullDownRefresh();
      });
  },

  // 修改切换标签方法
  switchTab(e) {
    const tab = e.currentTarget.dataset.tab;
    
    // 保存当前数据作为动画起点
    const startData = Array(tab === 'month' ? 31 : 7).fill(0);  // 根据目标视图初始化数组
    
    this.setData({
      activeTab: tab
    }, () => {
      // 更新显示日期
      this.updateDisplayDate();
      
      // 刷新图表数据
      this.refreshChartData();
      
      // 计算目标数据
      const targetData = this.getCurrentChartData(tab);
      
      // 计算并更新总电量显示
      const totalEnergy = this.calculateTotalEnergy(targetData);
      this.setData({
        displayEnergy: totalEnergy
      });
      
      // 设置动画参数
      const duration = 500;  // 增加动画时长
      const fps = 60;
      const frames = duration / (1000 / fps);
      let frame = 0;
      
      // 开始动画
      this.setData({
        'animation.startData': startData,
        'animation.targetData': targetData,
        'animation.isAnimating': true,
        'animation.duration': duration
      }, () => {
        // 清除可能存在的旧定时器
        if (this.data.animation.timer) {
          clearInterval(this.data.animation.timer);
        }
        
        // 创建新的动画定时器
        const timer = setInterval(() => {
          frame++;
          const progress = frame / frames;
          
          if (progress >= 1) {
            clearInterval(timer);
            this.setData({
              'animation.isAnimating': false,
              'animation.timer': null
            });
            this.drawChart();
          } else {
            this.setData({
              'animation.progress': progress
            }, () => {
              this.drawChart();
            });
          }
        }, 1000 / fps);
        
        this.setData({
          'animation.timer': timer,
          'animation.progress': 0
        }, () => {
          this.drawChart();
        });
      });
    });
  },

  // 获取当前图表数据
  getCurrentChartData(tab) {
    const { year, month, day } = this.data.selectedDate;
    const data = [];

    if (tab === 'week') {
      // 获取所选日期所在周的起始日期
      const selectedDate = new Date(year, month - 1, day);
      const weekStart = new Date(selectedDate);
      weekStart.setDate(selectedDate.getDate() - selectedDate.getDay());  // 设置为本周日
      
      // 收集一周的数据
      for (let i = 0; i < 7; i++) {
        const targetDate = new Date(weekStart);
        targetDate.setDate(weekStart.getDate() + i);
        
        const record = this.data.energyRecords.find(r => 
          r.year === targetDate.getFullYear() &&
          r.month === (targetDate.getMonth() + 1) &&
          r.day === targetDate.getDate()
        );
        
        data.push(record ? (record.energy / 1000).toFixed(3) : 0);
      }
    } else if (tab === 'month') {
      // 获取所选月份的天数
      const daysInMonth = new Date(year, month, 0).getDate();
      
      // 收集当月每天的数据
      for (let i = 1; i <= daysInMonth; i++) {
        const record = this.data.energyRecords.find(r => 
          r.year === year &&
          r.month === month &&
          r.day === i
        );
        
        data.push(record ? Number((record.energy / 1000).toFixed(3)) : 0);
      }
    }

    return data;
  },

  // 修改动画实现
  startChartAnimation() {
    // 清除可能存在的旧定时器
    if (this.data.animation.timer) {
      clearInterval(this.data.animation.timer);
    }

    const startTime = Date.now();
    const duration = this.data.animation.duration;
    
    // 使用 setInterval 代替 requestAnimationFrame
    const timer = setInterval(() => {
      const progress = Math.min((Date.now() - startTime) / duration, 1);
      
      // 使用缓动函数
      const eased = this.easeOutCubic(progress);
      
      this.setData({
        'animation.progress': eased
      }, () => {
        this.drawChart();
        
        if (progress >= 1) {
          clearInterval(timer);
          this.setData({
            'animation.isAnimating': false,
            'animation.timer': null
          });
        }
      });
    }, 16); // 约60fps
    
    this.setData({
      'animation.timer': timer
    });
  },

  // 缓动函数
  easeOutCubic(t) {
    return 1 - Math.pow(1 - t, 3);
  },

  // 页面跳转方法：跳转到定时页面
  showTimer() {
    if (!this.data.isConnected) {
      wx.showToast({
        title: '请先连接设备',
        icon: 'none'
      });
      return;
    }

    // 保存当前的消息处理器
    const currentHandler = this.handleReceivedData.bind(this);

    wx.navigateTo({
      url: '/pages/timer/timer',
      success: (res) => {
        // 将连接状态传递给定时页面
        res.eventChannel.emit('deviceConnected', { 
          isConnected: true,
          udpManager: this.data.udpManager 
        });

        // 监听页面返回事件
        res.eventChannel.on('returnFromTimer', () => {
          // 重新绑定消息处理器
          if (this.data.udpManager) {
            this.data.udpManager.onMessage(currentHandler);
          }
        });
      }
    });
  },

  // 页面跳转方法：跳转到设置页面
  openSettings() {
    console.log('[设置] 打开设置页面');
    wx.navigateTo({
      url: '/pages/settings/settings'
    });
  },

  // 开始扫描设备
  startScan() {
    const { mdnsManager } = this.data;
    if (!mdnsManager || this.data.scanning) {
      console.log('[扫描] 扫描已在进行中或管理器未初始化');
      return;
    }

    // 先清空设备列表
    this.setData({
      deviceList: [],
      scanning: true
    });

    mdnsManager.startScan()
      .catch(err => {
        console.error('[扫描] 扫描启动失败:', err);
        // 只有在非"已在进行中"的错误时才显示提示
        if (!err.message || !err.message.includes('扫描已在进行中')) {
          wx.showToast({
            title: '设备扫描失败',
            icon: 'none'
          });
        }
        this.setData({ scanning: false });
      });
  },

  // 停止扫描
  stopScan() {
    const { mdnsManager } = this.data;
    if (!mdnsManager) return;

    console.log('[扫描] 停止扫描');
    
    mdnsManager.stopScan()
      .then(() => {
        console.log('[扫描] 扫描已停止');
        this.setData({ scanning: false });
      })
      .catch((err) => {
        console.error('[扫描] 停止扫描失败:', err);
      })
      .finally(() => {
        wx.stopPullDownRefresh();
      });
  },

  // 刷新设备状态
  refreshDeviceStatus() {
    console.log('[设备] 开始刷新设备状态');
    
    const deviceList = this.data.deviceList;
    if (deviceList.length === 0) {
      console.log('[设备] 设备列表为空，跳过刷新');
      return;
    }

    // TODO: 调用API获取设备在线状态
    deviceList.forEach((device, index) => {
      // 这里模拟设备状态更新
      const oldStatus = deviceList[index].connected;
      deviceList[index].connected = Math.random() > 0.5;
      console.log('[设备] 状态更新:', {
        device: device.name,
        oldStatus,
        newStatus: deviceList[index].connected
      });
    });

    this.setData({ deviceList });
    console.log('[设备] 状态刷新完成');
  },

  // 连接设备
  connectDevice(e) {
    const device = e.currentTarget.dataset.device;
    console.log('[设备] 开始连接设备:', device);
    
    if (!device.ip || !device.port) {
      console.error('[UDP] IP或端口无效:', device);
      wx.showToast({
        title: '设备信息无效',
        icon: 'none'
      });
      return;
    }

    this.setData({ 
      connecting: true,
      currentDevice: device
    });

    wx.showLoading({
      title: '正在连接...'
    });

    // 使用实例方法
    const { udpManager } = this.data;
    udpManager.connect(device.ip, device.port)
      .then(() => {
        console.log('[UDP] Socket 创建成功');
        
        // 获取当前日期
        const now = new Date();
        
        this.setData({
          tcpConnected: true,
          isConnected: true,
          connecting: false,
          // 设置当前日期为选中日期
          selectedDate: {
            year: now.getFullYear(),
            month: now.getMonth() + 1,
            day: now.getDate()
          }
        }, () => {
          // 更新显示日期
          this.updateDisplayDate();
        });

        // 查询设备信息
        this.queryDeviceInfo();
                
        // 查询设备开关状态
        this.querySwitchState();
        // 查询用电记录
        this.queryEnergyRecords();
        // 启动电气参数查询
        udpManager.startQuery();
        // 启动今日用电量定时查询
        this.startTodayEnergyQuery();
        
        // 设置到数据中，确保 this.data.udpManager 存在
        this.setData({
          udpManager: udpManager
        });
        
        // 保存 udpManager 到 globalData
        getApp().globalData.udpManager = udpManager;
        
        // 如果使用共享模块，也需要初始化
        if (sharedUdpManager.initialize) {
          sharedUdpManager.initialize(udpManager);
        }
        
        wx.hideLoading();
        wx.showToast({
          title: '连接成功',
          icon: 'success'
        });
      })
      .catch(err => {
        console.error('[UDP] 操作失败:', err);
        this.handleDisconnect();
      });
  },

  // 断开连接处理
  handleDisconnect() {
    console.log('[UDP] 开始断开连接');
    
    const { udpManager } = this.data;
    udpManager.disconnect()
      .then(() => {
        console.log('[UDP] 断开连接成功');
        this.setData({
          tcpConnected: false,
          isConnected: false,
          connecting: false,
          currentDevice: null,
          // 重置电气参数显示
          currentPower: '--',
          voltage: '--',
          current: '--',
          todayEnergy: '--',
          energyRecords: [],
          recordCount: 0,
          currentRecordIndex: 0
        });

        // 停止今日用电量定时查询
        this.stopTodayEnergyQuery();

        wx.hideLoading();
        wx.showToast({
          title: '连接已断开',
          icon: 'none'
        });
      });
  },

  // 修改下拉刷新方法
  onPullDownRefresh() {
    console.log('[刷新] 开始下拉刷新');
    
    // 重置扫描状态和设备列表
    this.setData({
      scanning: false,
      deviceList: []
    });
    
    if (!this.data.showDeviceList) {
      // 首次下拉，显示设备列表
      this.setData({
        showDeviceList: true
      });
    }

    // 确保停止之前的扫描
    const { mdnsManager } = this.data;
    if (mdnsManager) {
      mdnsManager.stopScan()
        .then(() => {
          // 等待一小段时间后再开始新的扫描
          setTimeout(() => {
            this.startScan();
          }, 100);
        })
        .catch(() => {
          // 即使停止扫描失败也继续尝试开始新的扫描
          this.startScan();
        });
    }

    // 设置扫描超时
    setTimeout(() => {
      if (this.data.scanning) {
        console.log('[扫描] 超时自动停止'); 
        this.stopScan();
      }
      wx.stopPullDownRefresh();
    }, 1000);
  },

  // 页面滚动监听
  onPageScroll(e) {
    // 记录滚动位置，用于判断是否需要隐藏设备列表
    if (e.scrollTop > 100 && this.data.showDeviceList) {
      // 当向上滚动超过一定距离时，隐藏设备列表
      this.setData({
        showDeviceList: false
      });
      // 停止扫描
      this.stopScan();
    }
  },

  // 添加上拉加载更多方法
  onReachBottom() {
    console.log('[加载] 触发上拉加载');
    
    if (!this.data.hasMore || this.data.isLoading) {
      console.log('[加载] 无更多数据或正在加载中');
      return;
    }

    this.setData({ isLoading: true });
    
    // 模拟加载更多设备
    setTimeout(() => {
      // 这里可以加载更多设备数据
      // 当没有更多数据时，设置 hasMore 为 false
      this.setData({
        currentPage: this.data.currentPage + 1,
        isLoading: false
      });
      
      console.log('[加载] 上拉加载完成');
    }, 1000);
  },

  // 页面卸载时清理
  onUnload() {
    const { udpManager, mdnsManager } = this.data;
    // 确保在页面卸载时停止扫描
    if (mdnsManager) {
      mdnsManager.stopScan().catch(() => {});
    }
    if (udpManager) {
      udpManager.disconnect();
    }

    // 停止今日用电量定时查询
    this.stopTodayEnergyQuery();

    if (getApp().globalData?.chart) {
      getApp().globalData.chart.dispose();
      getApp().globalData.chart = null;
    }

    if (this.data.animation.timer) {
      clearInterval(this.data.animation.timer);
    }
  },

  // 修改数据处理回调
  handleReceivedData(data) {
    const result = CommandManager.parseFrame(data);
    if (!result) return;

    if (result.cmd === ElectricalDataCommand.CMD) {
      // 更新电气参数显示
      this.setData({
        currentPower: result.data.power.toFixed(1),
        voltage: result.data.voltage.toFixed(3),
        current: result.data.current.toFixed(3),
      });
    } else if (result.cmd === SwitchStateCommand.CMD) {
      // 开关命令响应处理
      console.log('[开关] 收到响应:', result);
      
      // 清除超时定时器
      if (this.data.loadingTimeout) {
        clearTimeout(this.data.loadingTimeout);
        this.setData({ loadingTimeout: null });
      }
      
      wx.hideLoading();
      
      if (result.data.success) {
        this.setData({
          isPowerOn: result.data.state
        });
        
        wx.showToast({
          title: this.data.isPowerOn ? '已开启' : '已关闭',
          icon: 'success'
        });
      } else {
        wx.showToast({
          title: '操作失败',
          icon: 'error'
        });
      }
    } else if (result.cmd === QuerySwitchStateCommand.CMD) {
      // 处理查询开关状态响应
      console.log('[开关] 收到查询响应:', result);
      
      // 更新开关状态
      this.setData({
        isPowerOn: result.data.state
      });
    } else if (result.cmd === QueryEnergyCountCommand.CMD) {
      // 处理记录总数查询响应
      const count = result.data.count;  // 从 data 对象中获取 count 值
      console.log('[记录] 总数:', count);
      
      this.setData({
        recordCount: count,
        currentRecordIndex: 0,
        energyRecords: []  // 清空之前的记录
      }, () => {
        // 只有当有记录时才开始查询
        if (count > 0) {
          this.queryEnergyRecord(0);
        }
      });
    } else if (result.cmd === QueryEnergyRecordCommand.CMD) {
      const { year, month, day, energy } = result.data;
      
      // 添加或更新记录
      const records = [...this.data.energyRecords];
      records.push({
        year: Number(year),
        month: Number(month),
        day: Number(day),
        energy: Number(energy) || 0
      });

      this.setData({
        energyRecords: records,
        currentRecordIndex: this.data.currentRecordIndex + 1
      });

      // 如果还有更多记录，继续查询
      const nextIndex = this.data.currentRecordIndex;
      if (nextIndex < this.data.recordCount) {
        this.queryEnergyRecord(nextIndex);
      } else {
        console.log('[记录] 查询完成, 共获取记录:', records.length);
        // 只在所有记录获取完成后重绘一次
        this.drawChart();
        
        // 数据加载完成后，更新左上角电量显示
        const data = this.getCurrentChartData(this.data.activeTab);
        const totalEnergy = this.calculateTotalEnergy(data);
        this.setData({
          displayEnergy: totalEnergy
        });
      }
    } else if (result.cmd === QueryEnergyDateCommand.CMD) {
      // 处理日期查询响应
      const { year, month, day, energy } = result.data;
      
      // 检查数据有效性
      if (!year || !month || !day || energy === undefined) {
        console.error('[记录] 无效数据:', result.data);
        return;
      }

      // 获取当前日期
      const today = new Date();
      const isToday = year === today.getFullYear() && 
                      month === (today.getMonth() + 1) && 
                      day === today.getDate();
      
      // 添加或更新记录
      const records = [...this.data.energyRecords];
      const existingIndex = records.findIndex(r => 
        r.year === year && r.month === month && r.day === day
      );
      
      if (existingIndex >= 0) {
        records[existingIndex].energy = energy;
        // 更新记录并重绘图表
        this.setData({
          energyRecords: records,
          todayEnergy: isToday ? (energy / 1000).toFixed(3) : this.data.todayEnergy // 将 Wh 转换为 kWh，并保留三位小数
        }, () => {
          this.drawChart();
        });
      }
    }
  },

  // 处理状态更新数据
  handleStatusUpdate(data) {
    // TODO: 根据协议解析状态数据
    // 这里假设数据格式为：
    // [power(1), currentPower(4), voltage(2), current(2), energy(4)]
    this.setData({
      isPowerOn: data[0] === 1,
      currentPower: (data[1] << 24 | data[2] << 16 | data[3] << 8 | data[4]) / 10,
      voltage: (data[5] << 8 | data[6]) / 10,
      current: (data[7] << 8 | data[8]) / 100,
      todayEnergy: (data[9] << 24 | data[10] << 16 | data[11] << 8 | data[12]) / 1000
    });
  },

  // 查询开关状态
  querySwitchState() {
    const { udpManager } = this.data;
    const frame = CommandManager.createCommand('QUERY_SWITCH_STATE');
    if (!frame) return;
    
    udpManager.send(frame)
      .catch(err => {
        console.error('[开关] 查询状态失败:', err);
      });
  },

  // 查询用电记录
  queryEnergyRecords() {
    const { udpManager } = this.data;
    // 先查询记录总数
    const frame = CommandManager.createCommand('QUERY_ENERGY_COUNT');
    if (!frame) return;
    
    // 先将今日用电量设置为0
    this.setData({
      todayEnergy: '0.000'
    });

    udpManager.send(frame)
      .catch(err => {
        console.error('[记录] 查询总数失败:', err);
      });
  },

  // 查询指定索引的记录
  queryEnergyRecord(index) {
    const { udpManager } = this.data;
    const frame = CommandManager.createCommand('QUERY_ENERGY_RECORD', index);
    if (!frame) return;
    
    udpManager.send(frame)
      .catch(err => {
        console.error('[记录] 查询记录失败:', err);
      });
  },

  // 查询指定日期的用电量
  queryEnergyDate(date) {
    const { udpManager } = this.data;
    const frame = CommandManager.createCommand('QUERY_ENERGY_DATE', date);
    if (!frame) return;
    
    console.log('[日期查询] 查询日期:', date);
    
    return udpManager.send(frame)
      .catch(err => {
        console.error('[日期查询] 查询失败:', err);
      });
  },

  // 更新图表数据
  updateChart() {
    const app = getApp();
    const chart = app.globalData?.chart;
    
    // console.log('[图表] 当前状态:', {
    //   hasChart: !!chart,
    //   activeTab: this.data.activeTab,
    //   recordsCount: this.data.energyRecords.length
    // });
    
    if (!chart) {
      console.log('[图表] 等待图表初始化...');
      // 延迟重试更新
      setTimeout(() => {
        if (app.globalData?.chart) {
          this.updateChart();
        }
      }, 500);
      return;
    }
    
    const activeTab = this.data.activeTab;
    const records = this.data.energyRecords;
    
    // 根据不同时间维度处理数据
    let chartData = [];
    let xAxisData = [];
    
    const now = new Date();
    
    if (activeTab === 'week') {
      // 获取最近7天的数据
      const weekData = [];
      const weekLabels = [];
      
      // 获取本周的起始日期
      const weekStart = new Date(now);
      weekStart.setDate(now.getDate() - now.getDay());
      
      // 收集一周的数据
      for (let i = 0; i < 7; i++) {
        const targetDate = new Date(weekStart);
        targetDate.setDate(weekStart.getDate() + i);
        
        const record = records.find(r => 
          r.year === targetDate.getFullYear() &&
          r.month === (targetDate.getMonth() + 1) &&
          r.day === targetDate.getDate()
        );
        
        weekData.push(record ? (record.energy / 1000).toFixed(3) : 0);
        weekLabels.push(`${targetDate.getMonth() + 1}/${targetDate.getDate()}`);
      }
      
      chartData = weekData;
      xAxisData = weekLabels;
      
    } else if (activeTab === 'month') {
      // 获取本月数据
      const monthData = [];
      const monthLabels = [];
      
      const year = now.getFullYear();
      const month = now.getMonth() + 1;
      const daysInMonth = new Date(year, month, 0).getDate();
      
      for (let i = 1; i <= daysInMonth; i++) {
        const record = records.find(r => 
          r.year === year &&
          r.month === month &&
          r.day === i
        );
        
        monthData.push(record ? (record.energy / 1000).toFixed(3) : 0);
        monthLabels.push(`${i}日`);
      }
      
      chartData = monthData;
      xAxisData = monthLabels;
      
    }

    // 设置图表配置
    const option = {
      tooltip: {
        trigger: 'axis',
        formatter: function(params) {
          return `${params[0].name}<br/>用电量: ${params[0].value}kWh`;
        }
      },
      grid: {
        left: '10%',
        right: '5%',
        bottom: '15%',
        top: '10%',
        containLabel: true
      },
      xAxis: {
        type: 'category',
        data: xAxisData,
        axisLabel: {
          interval: 0,
          rotate: activeTab === 'month' ? 45 : 0,
          fontSize: 10
        }
      },
      yAxis: {
        type: 'value',
        name: '用电量',
        nameTextStyle: {
          fontSize: 10
        },
        axisLabel: {
          fontSize: 10
        },
        splitLine: {
          show: true,
          lineStyle: {
            type: 'dashed'
          }
        }
      },
      series: [{
        type: 'bar',
        data: chartData,
        itemStyle: {
          color: '#4cd964'
        },
        barWidth: activeTab === 'month' ? '60%' : '70%'
      }]
    };

    try {
      // 禁用动画以提高性能
      option.animation = false;
      // console.log('[图表] 更新配置:', option);
      chart.setOption(option, true); // 使用 true 参数不合并配置
      // console.log('[图表] 更新成功');
    } catch (err) {
      console.error('[图表] 更新失败:', err);
      // 如果更新失败，可能是图表实例失效，尝试重新初始化
      app.globalData.chart = null;
      const ecComponent = this.selectComponent('#energyChart');
      if (ecComponent) {
        console.log('[图表] 尝试重新初始化');
        ecComponent.init();
      }
    }
  },

  // 添加启动定时查询方法
  startTodayEnergyQuery() {
    // 先清除可能存在的定时器
    if (this.data.todayEnergyTimer) {
      clearInterval(this.data.todayEnergyTimer);
    }
    
    // 立即执行一次查询
    this.queryTodayEnergy();
    
    // 设置定时器,每5秒查询一次
    const timer = setInterval(() => {
      this.queryTodayEnergy();
    }, 5000);
    
    this.setData({
      todayEnergyTimer: timer
    });
  },

  // 添加停止定时查询方法
  stopTodayEnergyQuery() {
    if (this.data.todayEnergyTimer) {
      clearInterval(this.data.todayEnergyTimer);
      this.setData({
        todayEnergyTimer: null
      });
    }
  },

  // 添加查询今日用电量方法
  queryTodayEnergy() {
    const today = new Date();
    this.queryEnergyDate({
      year: today.getFullYear(),
      month: today.getMonth() + 1,
      day: today.getDate()
    });
  },

  // 添加图表初始化事件处理器
  onChartInit(e) {
    // console.log('[图表] 组件初始化事件:', e);
  },

  // 初始化图表
  initChart() {
    // console.log('[图表] 开始初始化');
    const query = wx.createSelectorQuery();
    query.select('#energyChart')
      .fields({ node: true, size: true })
      .exec((res) => {
        if (!res[0]) {
          console.error('[图表] 获取 Canvas 节点失败');
          return;
        }

        const canvas = res[0].node;
        const ctx = canvas.getContext('2d');
        
        // 设置 Canvas 大小
        const dpr = wx.getSystemInfoSync().pixelRatio;
        canvas.width = res[0].width * dpr;
        canvas.height = res[0].height * dpr;
        ctx.scale(dpr, dpr);

        this.setData({
          canvas: canvas,
          chartWidth: res[0].width,
          chartHeight: res[0].height,
          chartInitialized: true  // 标记图表已初始化
        }, () => {
          // console.log('[图表] 初始化完成，开始绘制');
          this.drawChart();  // 初始化完成后立即绘制
        });
      });
  },

  // 绘制图表
  drawChart() {
    const { canvas, chartWidth, chartHeight, chartInitialized } = this.data;
    
    // 检查图表是否已初始化
    if (!chartInitialized || !canvas) {
      console.log('[图表] 等待初始化完成');
      return;
    }

    // 获取当前上下文
    const ctx = canvas.getContext('2d');
    
    // 清空画布
    ctx.clearRect(0, 0, chartWidth, chartHeight);

    // 直接从 selectedDate 获取数据，不使用缓存的 chartData
    const labels = this.getChartLabels(this.data.activeTab);
    
    // 处理数据 - 直接调用 getCurrentChartData 获取最新数据
    let data = this.getCurrentChartData(this.data.activeTab);

    // 调整边距，增加底部空间以显示标签
    const padding = {
      left: 60,
      right: 30,
      top: 60,     // 增加顶部边距
      bottom: 70
    };

    // 计算图表区域
    const chartArea = {
      x: padding.left,
      y: padding.top,
      width: chartWidth - padding.left - padding.right,
      height: chartHeight - padding.top - padding.bottom
    };

    // 修改最大值计算逻辑
    const calculateYAxisRange = (maxValue) => {
      // 如果最大值太小，设置一个最小范围
      const minRange = 0.01;
      maxValue = Math.max(maxValue, minRange);
      
      // 计算合适的刻度
      const power = Math.floor(Math.log10(maxValue));
      const unit = Math.pow(10, power);
      // 将最大值稍微提高一点，确保柱状图不会顶到头
      const normalizedMax = Math.ceil((maxValue * 1.1) / unit) * unit;
      
      // 根据数据范围选择合适的步长
      let step;
      if (normalizedMax <= 0.1) {
        step = 0.02;
      } else if (normalizedMax <= 0.5) {
        step = 0.1;
      } else if (normalizedMax <= 1) {
        step = 0.2;
      } else if (normalizedMax <= 5) {
        step = 1;
      } else if (normalizedMax <= 10) {
        step = 2;
      } else {
        step = Math.ceil(normalizedMax / 5);
      }

      return {
        max: normalizedMax,  // 直接使用计算出的最大值
        step: step
      };
    };

    // 找出数据最大值并计算Y轴范围
    const maxDataValue = Math.max(...data, 0);
    const { max: yAxisMax, step: yAxisStep } = calculateYAxisRange(maxDataValue);

    // 修改样式相关的常量
    const COLORS = {
      primary: '#42b883',      // 更现代的绿色
      secondary: '#35495e',    // 深色辅助色
      grid: '#f5f5f5',        // 更浅的网格线颜色
      text: '#666666',        // 文字颜色
      label: '#999999'        // 标签颜色
    };

    const STYLES = {
      barMaxWidth: 40,        // 增加柱子最大宽度
      barRadius: 6,           // 增加柱子圆角
      fontSize: {
        label: 12,           // 增加标签字体大小
        value: 11,           // 增加数值字体大小
        unit: 12            // 增加单位字体大小
      },
      padding: {
        left: 60,           // 增加左边距，给Y轴刻度更多空间
        right: 30,          // 增加右边距
        top: 40,            // 增加顶部边距
        bottom: 70          // 增加底部边距，给X轴标签更多空间
      }
    };

    // 修改网格线绘制
    const drawGrid = () => {
      ctx.strokeStyle = COLORS.grid;
      ctx.lineWidth = 0.5;
      
      const steps = yAxisMax / yAxisStep;
      for (let i = 0; i <= steps; i++) {
        const y = chartArea.y + chartArea.height - (chartArea.height / steps * i);
        
        ctx.beginPath();
        ctx.moveTo(chartArea.x, y);
        ctx.lineTo(chartArea.x + chartArea.width, y);
        ctx.stroke();
      }
    };

    // 修改柱状图绘制
    const drawBars = () => {
      // 根据数据长度动态计算合适的柱子宽度
      const maxBarWidth = this.data.activeTab === 'month' 
        ? Math.min(12, chartArea.width / data.length * 0.5)  // 增加月视图柱子宽度
        : Math.min(STYLES.barMaxWidth, chartArea.width / data.length * 0.7);
      
      // 月视图不需要最小宽度限制
      const barWidth = this.data.activeTab === 'month' 
        ? maxBarWidth 
        : Math.max(20, maxBarWidth);
      
      // 月视图使用更小的间距
      const barGap = this.data.activeTab === 'month'
        ? (chartArea.width - barWidth * data.length) / (data.length + 1) * 0.9
        : (chartArea.width - barWidth * data.length) / (data.length + 1);
      
      data.forEach((value, index) => {
        // 确保所有值都是数字类型
        let currentValue = Number(value) || 0;
        
        if (this.data.animation.isAnimating) {
          const startValue = Number(this.data.animation.startData[index]) || 0;
          const targetValue = Number(this.data.animation.targetData[index]) || 0;
          currentValue = startValue + (targetValue - startValue) * this.data.animation.progress;
        }

        const barHeight = currentValue > 0 ? (currentValue / yAxisMax) * chartArea.height : 0;
        const x = chartArea.x + barGap + (barWidth + barGap) * index;
        const y = chartArea.y + chartArea.height - barHeight;

        // 检查是否是当前触摸的柱子
        const isTouched = this.data.touchInfo.touching && index === this.data.touchInfo.index;

        // 绘制柱子阴影
        ctx.save();
        
        // 为触摸的柱子增加特殊效果
        if (isTouched) {
          // 增加更明显的阴影效果
          ctx.shadowColor = 'rgba(46, 134, 222, 0.6)';
          ctx.shadowBlur = 15;
          ctx.shadowOffsetX = 0;
          ctx.shadowOffsetY = 5;
        } else {
          // 月视图减少阴影效果
          ctx.shadowColor = this.data.activeTab === 'month' 
            ? 'rgba(66, 184, 131, 0.05)'
            : 'rgba(66, 184, 131, 0.1)';
          ctx.shadowBlur = 10;
          ctx.shadowOffsetX = 0;
          ctx.shadowOffsetY = 4;
        }

        // 绘制渐变柱子
        const gradient = ctx.createLinearGradient(x, y, x, y + barHeight);
        
        if (isTouched) {
          // 触摸时使用不同的颜色
          gradient.addColorStop(0, '#2e86de');  // 较亮的蓝色
          gradient.addColorStop(1, '#54a0ff');  // 淡蓝色
        } else {
          gradient.addColorStop(0, COLORS.primary);
          gradient.addColorStop(1, COLORS.primary + '99');
        }
        
        ctx.fillStyle = gradient;
        
        // 绘制圆角柱子
        // 月视图使用更小的圆角
        const radius = this.data.activeTab === 'month'
          ? Math.min(3, barWidth / 4)
          : Math.min(STYLES.barRadius, barWidth / 4);

        ctx.beginPath();
        ctx.moveTo(x + radius, y);
        ctx.lineTo(x + barWidth - radius, y);
        ctx.quadraticCurveTo(x + barWidth, y, x + barWidth, y + radius);
        ctx.lineTo(x + barWidth, y + barHeight);
        ctx.lineTo(x, y + barHeight);
        ctx.lineTo(x, y + radius);
        ctx.quadraticCurveTo(x, y, x + radius, y);
        ctx.fill();

        // 为触摸的柱子添加边框效果
        if (isTouched) {
          ctx.strokeStyle = '#0984e3';  // 深蓝色边框
          ctx.lineWidth = 2;
          ctx.stroke();
          
          // 在柱子顶部绘制一个小圆点
          ctx.beginPath();
          ctx.fillStyle = '#fff';
          ctx.arc(x + barWidth/2, y - 2, 4, 0, Math.PI * 2);
          ctx.fill();
          
          // 为小圆点添加边框
          ctx.strokeStyle = '#0984e3';
          ctx.lineWidth = 1;
          ctx.stroke();
        }

        ctx.restore();

        // 绘制标签
        ctx.fillStyle = isTouched ? '#0984e3' : COLORS.text;  // 触摸时标签颜色也变化
        ctx.font = `${STYLES.fontSize.label}px sans-serif`;
        ctx.textAlign = 'center';
        
        // 根据不同视图调整标签显示
        if (this.data.activeTab === 'month') {
          // 月视图标签垂直显示
          const day = index + 1;
          // 计算需要显示的日期
          const daysToShow = [
            1,  // 第一天
            Math.round(labels.length * 0.25),  // 25%位置
            Math.round(labels.length * 0.5),   // 50%位置
            Math.round(labels.length * 0.75),  // 75%位置
            labels.length  // 最后一天
          ];
          
          if (daysToShow.includes(day)) {
            ctx.fillText(labels[index], x + barWidth/2, chartArea.y + chartArea.height + 30);
          }
        } else {
          // 周视图标签正常显示
          ctx.fillText(labels[index], x + barWidth/2, chartArea.y + chartArea.height + 30);
        }

        // 修改数值显示逻辑
        if ((this.data.activeTab === 'week' && currentValue > 0 && !isTouched) || 
            (isTouched) || 
            (this.data.activeTab === 'month' && 
             this.data.touchInfo.touching && 
             index === this.data.touchInfo.index)) {
          // 触摸时使用更显眼的字体和颜色
          if (isTouched) {
            ctx.fillStyle = '#0984e3';  // 蓝色
            ctx.font = `bold ${STYLES.fontSize.value + 1}px sans-serif`;
          } else {
            ctx.fillStyle = COLORS.label;
            ctx.font = `${STYLES.fontSize.value}px sans-serif`;
          }
          ctx.fillText(currentValue.toFixed(3), x + barWidth/2, y - 10);
        }
      });
    };

    // 修改Y轴刻度绘制
    const drawYAxis = () => {
      const steps = yAxisMax / yAxisStep;
      ctx.fillStyle = COLORS.text;
      ctx.font = `${STYLES.fontSize.label}px sans-serif`;
      ctx.textAlign = 'right';
      
      for (let i = 0; i <= steps; i++) {
        const value = (yAxisStep * i).toFixed(3);
        const y = chartArea.y + chartArea.height - (chartArea.height / steps * i);
        ctx.fillText(value, chartArea.x - 10, y + 4);
      }
    };

    // 绘制单位
    const drawUnit = () => {
      ctx.save();
      
      // 设置字体样式 - 优化字体大小比例
      const valueFontSize = 20; // 数值使用较大字号
      const unitFontSize = 14;  // 单位使用适中字号
      const labelFontSize = 12; // 标签使用小号字号
      
      // 计算位置 - 调整顶部边距
      const leftMargin = padding.left - 40;
      const topMargin = 20; // 将顶部边距从28减小到20
      
      // 绘制耗电量值
      const displayValue = this.data.displayEnergy;
      ctx.fillStyle = '#2C3E50';
      ctx.font = `500 ${valueFontSize}px -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif`;
      ctx.textAlign = 'left';
      const valueWidth = ctx.measureText(displayValue).width;
      ctx.fillText(displayValue, leftMargin, topMargin);
      
      // 绘制"度"字
      ctx.fillStyle = '#34495E';
      ctx.font = `normal ${unitFontSize}px -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif`;
      ctx.fillText('度', leftMargin + valueWidth + 3, topMargin);
      
      // 绘制标签 - 相应调整标签的位置
      ctx.fillStyle = '#95A5A6';
      ctx.font = `normal ${labelFontSize}px -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif`;
      ctx.fillText('用电量', leftMargin, topMargin + 15);
      
      ctx.restore();
    };

    // 按顺序执行绘制
    drawGrid();
    drawBars();
    drawYAxis();
    drawUnit();
    // console.log('[图表] 绘制完成');
  },

  onReady() {
    this.initChart();
  },

  // 更新图表数据时调用
  updateChart() {
    this.drawChart();
  },

  // 获取图表标签
  getChartLabels(tab) {
    const { year, month, day } = this.data.selectedDate;
    
    if (tab === 'week') {
      // 获取所选日期所在周的起始日期
      const selectedDate = new Date(year, month - 1, day);
      const weekStart = new Date(selectedDate);
      weekStart.setDate(selectedDate.getDate() - selectedDate.getDay());
      
      // 生成一周的标签
      return Array.from({length: 7}, (_, i) => {
        const date = new Date(weekStart);
        date.setDate(weekStart.getDate() + i);
        return `${date.getMonth() + 1}/${date.getDate()}`;
      });
    } else if (tab === 'month') {
      // 获取所选月份的天数
      const daysInMonth = new Date(year, month, 0).getDate();
      
      // 生成当月的每一天
      return Array.from({length: daysInMonth}, (_, i) => 
        String(i + 1).padStart(2, '0')
      );
    }
    return [];
  },

  // 在页面隐藏时清理定时器
  onHide() {
    if (this.data.animation.timer) {
      clearInterval(this.data.animation.timer);
      this.setData({
        'animation.timer': null,
        'animation.isAnimating': false
      });
    }

    if (getApp().globalData.deviceInfo === null) {
      // 查询设备信息
      this.queryDeviceInfo();
    }
  },

  // 获取触摸点对应的柱状图索引
  getTouchedBarIndex(touchX, touchY) {
    const { chartWidth, chartHeight } = this.data;
    const padding = {
      left: 60,
      right: 30,
      top: 40,
      bottom: 70
    };
    
    const chartArea = {
      x: padding.left,
      y: padding.top,
      width: chartWidth - padding.left - padding.right,
      height: chartHeight - padding.top - padding.bottom
    };
    
    // 计算柱子宽度和间距
    const data = this.getCurrentChartData(this.data.activeTab);
    const maxBarWidth = Math.min(12, chartArea.width / data.length * 0.5);
    const barWidth = maxBarWidth;
    const barGap = (chartArea.width - barWidth * data.length) / (data.length + 1) * 0.9;
    
    // 检查触摸点是否在图表区域内
    if (touchX < chartArea.x || touchX > chartArea.x + chartArea.width ||
        touchY < chartArea.y || touchY > chartArea.y + chartArea.height) {
      return -1;
    }
    
    // 计算触摸点对应的柱子索引
    const relativeX = touchX - chartArea.x - barGap;
    const index = Math.floor(relativeX / (barWidth + barGap));
    
    return index >= 0 && index < data.length ? index : -1;
  },

  // 计算总耗电量
  calculateTotalEnergy(data) {
    return data.reduce((sum, value) => sum + Number(value), 0).toFixed(3);
  },

  // 修改触摸开始事件
  touchChart(e) {
    const touch = e.touches[0];
    const index = this.getTouchedBarIndex(touch.x, touch.y);
    const data = this.getCurrentChartData(this.data.activeTab);
    const totalEnergy = this.calculateTotalEnergy(data);
    
    if (index >= 0) {
      let energy = '0.000';
      let touchDate = '';
      
      if (this.data.activeTab === 'week') {
        // 周视图 - 获取当前所选周对应的日期
        const selectedDate = new Date(this.data.selectedDate.year, this.data.selectedDate.month - 1, this.data.selectedDate.day);
        const weekStart = new Date(selectedDate);
        weekStart.setDate(selectedDate.getDate() - selectedDate.getDay());  // 设置为本周日
        
        // 计算触摸的那天的日期
        const targetDate = new Date(weekStart);
        targetDate.setDate(weekStart.getDate() + index);
        
        // 查找对应日期的记录
        const record = this.data.energyRecords.find(r => 
          r.year === targetDate.getFullYear() &&
          r.month === (targetDate.getMonth() + 1) &&
          r.day === targetDate.getDate()
        );
        
        energy = record ? (record.energy / 1000).toFixed(3) : '0.000';
        const formatNumber = num => num < 10 ? `0${num}` : num;
        touchDate = `${targetDate.getFullYear()}/${formatNumber(targetDate.getMonth() + 1)}/${formatNumber(targetDate.getDate())}`;
      } else {
        // 月视图 - 使用原有逻辑
        const { year, month } = this.data.selectedDate;
        const record = this.data.energyRecords.find(r => 
          r.year === year &&
          r.month === month &&
          r.day === index + 1
        );
        
        energy = record ? (record.energy / 1000).toFixed(3) : '0.000';
        const formatNumber = num => num < 10 ? `0${num}` : num;
        touchDate = `${year}/${formatNumber(month)}/${formatNumber(index + 1)}`;
      }

      this.setData({
        'touchInfo.touching': true,
        'touchInfo.index': index,
        'touchInfo.totalEnergy': totalEnergy,
        'touchInfo.currentEnergy': energy,
        'touchInfo.currentDate': touchDate,
        displayDate: touchDate,
        displayEnergy: energy
      }, () => {
        this.drawChart();
      });
    } else {
      // 触摸到空白区域，显示总量
      this.setData({
        'touchInfo.touching': true,
        'touchInfo.index': -1,
        'touchInfo.totalEnergy': totalEnergy,
        displayEnergy: totalEnergy,
        displayDate: this.getDefaultDateDisplay()
      }, () => {
        this.drawChart();
      });
    }
  },

  // 获取周视图对应日期
  getWeekDate(index) {
    const { year, month, day } = this.data.selectedDate;
    const selectedDate = new Date(year, month - 1, day);
    const weekStart = new Date(selectedDate);
    weekStart.setDate(selectedDate.getDate() - selectedDate.getDay());
    const targetDate = new Date(weekStart);
    targetDate.setDate(weekStart.getDate() + index);
    
    // 修改为斜杠分隔的格式
    const formatNumber = num => num < 10 ? `0${num}` : num;
    return `${targetDate.getFullYear()}/${formatNumber(targetDate.getMonth() + 1)}/${formatNumber(targetDate.getDate())}`;
  },

  // 获取默认日期显示
  getDefaultDateDisplay() {
    const { year, month, day } = this.data.selectedDate;
    if (this.data.activeTab === 'week') {
      const selectedDate = new Date(year, month - 1, day);
      const weekStart = new Date(selectedDate);
      weekStart.setDate(selectedDate.getDate() - selectedDate.getDay());
      const weekEnd = new Date(weekStart);
      weekEnd.setDate(weekStart.getDate() + 6);
      return `${weekStart.getMonth() + 1}/${weekStart.getDate()}-${weekEnd.getMonth() + 1}/${weekEnd.getDate()}`;
    } else {
      return `${year}/${month}`;
    }
  },

  // 修改触摸移动事件
  moveChart(e) {
    const touch = e.touches[0];
    const index = this.getTouchedBarIndex(touch.x, touch.y);
    const data = this.getCurrentChartData(this.data.activeTab);
    const totalEnergy = this.calculateTotalEnergy(data);
    
    if (index >= 0 && index !== this.data.touchInfo.index) {
      let energy = '0.000';
      let touchDate = '';
      
      if (this.data.activeTab === 'week') {
        // 周视图 - 获取当前所选周对应的日期
        const selectedDate = new Date(this.data.selectedDate.year, this.data.selectedDate.month - 1, this.data.selectedDate.day);
        const weekStart = new Date(selectedDate);
        weekStart.setDate(selectedDate.getDate() - selectedDate.getDay());  // 设置为本周日
        
        // 计算触摸的那天的日期
        const targetDate = new Date(weekStart);
        targetDate.setDate(weekStart.getDate() + index);
        
        // 查找对应日期的记录
        const record = this.data.energyRecords.find(r => 
          r.year === targetDate.getFullYear() &&
          r.month === (targetDate.getMonth() + 1) &&
          r.day === targetDate.getDate()
        );
        
        energy = record ? (record.energy / 1000).toFixed(3) : '0.000';
        const formatNumber = num => num < 10 ? `0${num}` : num;
        touchDate = `${targetDate.getFullYear()}/${formatNumber(targetDate.getMonth() + 1)}/${formatNumber(targetDate.getDate())}`;
      } else {
        // 月视图 - 使用原有逻辑
        const { year, month } = this.data.selectedDate;
        const record = this.data.energyRecords.find(r => 
          r.year === year &&
          r.month === month &&
          r.day === index + 1
        );
        
        energy = record ? (record.energy / 1000).toFixed(3) : '0.000';
        const formatNumber = num => num < 10 ? `0${num}` : num;
        touchDate = `${year}/${formatNumber(month)}/${formatNumber(index + 1)}`;
      }

      this.setData({
        'touchInfo.index': index,
        'touchInfo.currentEnergy': energy,
        'touchInfo.currentDate': touchDate,
        displayDate: touchDate,
        displayEnergy: energy
      }, () => {
        this.drawChart();
      });
    } else if (index < 0 && this.data.touchInfo.index !== -1) {
      // 移动到空白区域
      this.setData({
        'touchInfo.index': -1,
        displayEnergy: totalEnergy,
        displayDate: this.getDefaultDateDisplay()
      }, () => {
        this.drawChart();
      });
    }
  },

  // 修改触摸结束事件
  touchEnd() {
    const data = this.getCurrentChartData(this.data.activeTab);
    const totalEnergy = this.calculateTotalEnergy(data);
    
    this.setData({
      'touchInfo.touching': false,
      'touchInfo.index': -1,
      displayEnergy: totalEnergy,
      displayDate: this.getDefaultDateDisplay()
    }, () => {
      this.drawChart();
    });
  },

  // 显示日期选择器
  showDatePicker() {
    const { year, month, day } = this.data.selectedDate;
    this.setData({
      showDatePicker: true,
      tempDate: { year, month, day }
    }, () => {
      // 确保在设置完数据后生成日历
      this.generateCalendar();
    });
  },

  // 隐藏日期选择器
  hideDatePicker() {
    this.setData({
      showDatePicker: false
    });
  },

  // 生成日历数据
  generateCalendar() {
    const { tempDate } = this.data;
    const { year, month } = tempDate;
    
    // 获取当月第一天是星期几
    const firstDay = new Date(year, month - 1, 1).getDay();
    
    // 获取当月天数
    const daysInMonth = new Date(year, month, 0).getDate();
    
    // 获取上月天数
    const daysInPrevMonth = new Date(year, month - 1, 0).getDate();
    
    // 获取当前日期，用于限制选择和标记今天
    const now = new Date();
    const currentYear = now.getFullYear();
    const currentMonth = now.getMonth() + 1;
    const currentDay = now.getDate();
    
    // 生成当月日期数组
    const days = [];
    for (let i = 1; i <= daysInMonth; i++) {
      // 检查日期是否超过今天
      const isFuture = (year > currentYear) || 
                      (year === currentYear && month > currentMonth) ||
                      (year === currentYear && month === currentMonth && i > currentDay);
      
      // 检查是否是今天
      const isToday = year === currentYear && month === currentMonth && i === currentDay;
      
      days.push({
        day: i,
        disabled: isFuture,
        today: isToday
      });
    }
    
    // 生成上月显示的日期
    const prevMonthDays = [];
    for (let i = 0; i < firstDay; i++) {
      prevMonthDays.push({
        day: daysInPrevMonth - firstDay + i + 1,
        other: true
      });
    }
    
    // 计算需要显示的下月天数
    const totalCells = Math.ceil((firstDay + daysInMonth) / 7) * 7;
    const nextMonthDays = [];
    for (let i = 1; i <= totalCells - (firstDay + daysInMonth); i++) {
      nextMonthDays.push({
        day: i,
        other: true
      });
    }
    
    this.setData({
      days,
      prevMonthDays,
      nextMonthDays
    });
  },

  // 切换月份
  changeMonth(e) {
    const { type } = e.currentTarget.dataset;
    let { year, month } = this.data.tempDate;
    
    // 获取当前日期，用于限制选择
    const now = new Date();
    const currentYear = now.getFullYear();
    const currentMonth = now.getMonth() + 1;
    const currentDay = now.getDate();
    
    if (type === 'prev') {
      if (month === 1) {
        year--;
        month = 12;
      } else {
        month--;
      }
    } else {
      // 限制不能选择未来的月份
      if (year === currentYear && month === currentMonth) {
        // 已经是当前月份，不能再往后选
        return;
      }
      
      if (month === 12) {
        year++;
        month = 1;
      } else {
        month++;
      }
      
      // 检查是否超过当前月份
      if (year > currentYear || (year === currentYear && month > currentMonth)) {
        // 回退到当前月份
        year = currentYear;
        month = currentMonth;
      }
    }
    
    // 获取当前选择的日期
    let { day } = this.data.tempDate;
    
    // 检查新月份的天数
    const daysInMonth = new Date(year, month, 0).getDate();
    
    // 如果当前选择的日期超过了新月份的天数，则调整为新月份的最后一天
    if (day > daysInMonth) {
      day = daysInMonth;
    }
    
    // 如果切换到当前月份，确保不选择未来日期
    if (year === currentYear && month === currentMonth && day > currentDay) {
      day = currentDay;
    }
    
    this.setData({
      'tempDate.year': year,
      'tempDate.month': month,
      'tempDate.day': day
    }, () => {
      this.generateCalendar();
    });
  },

  // 选择日期
  selectDate(e) {
    const { day, disabled } = e.currentTarget.dataset;
    
    // 如果日期被禁用，则不允许选择
    if (disabled === "true") {
      return;
    }
    
    this.setData({
      'tempDate.day': day
    });
  },

  // 确认日期选择
  confirmDateSelection() {
    const { year, month, day } = this.data.tempDate;
    console.log('[日期选择] 确认选择:', { year, month, day });
    
    // 先隐藏日期选择器
    this.setData({
      showDatePicker: false
    });
    
    // 使用 setTimeout 确保 UI 更新后再更新数据和图表
    setTimeout(() => {
      this.setData({
        selectedDate: {
          year,
          month,
          day: day || 1
        }
      }, () => {
        // 在回调中确保数据已更新后再执行这些操作
        this.updateDisplayDate();
        
        // 清除可能存在的动画
        if (this.data.animation.timer) {
          clearInterval(this.data.animation.timer);
          this.setData({
            'animation.isAnimating': false,
            'animation.timer': null
          });
        }
        
        // 计算并更新总电量显示
        const data = this.getCurrentChartData(this.data.activeTab);
        const totalEnergy = this.calculateTotalEnergy(data);
        this.setData({
          displayEnergy: totalEnergy
        });
        
        // 直接绘制图表，不使用动画
        this.drawChart();
      });
    }, 50);
  },

  // 修改更新显示日期的方法
  updateDisplayDate() {
    const { year, month, day } = this.data.selectedDate;
    const { activeTab } = this.data;
    
    let displayDate = '';
    if (activeTab === 'week') {
      // 获取所选日期所在周的起始日期和结束日期
      const selectedDate = new Date(year, month - 1, day);
      const weekStart = new Date(selectedDate);
      weekStart.setDate(selectedDate.getDate() - selectedDate.getDay());
      
      const weekEnd = new Date(weekStart);
      weekEnd.setDate(weekStart.getDate() + 6);
      
      // 格式化为 MM/DD-MM/DD 格式
      const startMonth = weekStart.getMonth() + 1;
      const startDay = weekStart.getDate();
      const endMonth = weekEnd.getMonth() + 1;
      const endDay = weekEnd.getDate();
      
      displayDate = `${startMonth}/${startDay}-${endMonth}/${endDay}`;
    } else {
      // 月视图，显示年月
      displayDate = `${year}/${month}`;
    }
    
    this.setData({
      displayDate
    });
  },

  // 刷新图表数据
  refreshChartData() {
    // 不需要发送查询指令，直接从现有记录中查找数据
    // 延迟一段时间后重绘图表
    setTimeout(() => {
      this.drawChart();
    }, 100);
  },

  // 查询设备信息
  async queryDeviceInfo() {
    if (!this.data.udpManager || !this.data.udpManager.isConnected) {
      console.error('[首页] UDP未连接')
      return
    }

    try {
      const frame = CommandManager.createQueryDeviceInfoCommand()
      if (!frame) {
        console.error('[首页] 创建查询设备信息命令失败')
        return
      }

      console.log('[首页] 发送查询设备信息命令')
      const response = await this.data.udpManager.sendAndWait(frame, 2000)
      
      const result = CommandManager.parseFrame(response)
      if (!result || !result.data) {
        console.error('[首页] 设备信息解析失败')
        return
      }

      console.log('[首页] 设备信息:', result.data)
      
      // 保存设备信息到全局状态
      getApp().globalData.deviceInfo = result.data

      // 更新页面显示
      this.setData({
        deviceInfo: result.data
      })
    } catch (error) {
      console.error('[首页] 查询设备信息失败:', error)
    }
  },
}) 